<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Class template multimap</title>
<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../../boost_container_header_reference.html#doxygen.boost_container_header_reference.map_8hpp" title="Header &lt;boost/container/map.hpp&gt;">
<link rel="prev" href="classboost_1_1container_1_1map.html" title="Class template map">
<link rel="next" href="structboost_1_1container_1_1pmr_1_1map__of.html" title="Struct template map_of">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
<td align="center"><a href="../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="classboost_1_1container_1_1map.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#doxygen.boost_container_header_reference.map_8hpp"><img src="../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="structboost_1_1container_1_1pmr_1_1map__of.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="refentry">
<a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap"></a><div class="titlepage"></div>
<div class="refnamediv">
<h2><span class="refentrytitle">Class template multimap</span></h2>
<p>boost::container::multimap</p>
</div>
<h2 class="refsynopsisdiv-title">Synopsis</h2>
<div class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="../../boost_container_header_reference.html#doxygen.boost_container_header_reference.map_8hpp" title="Header &lt;boost/container/map.hpp&gt;">boost/container/map.hpp</a>&gt;

</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> Compare <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span><span class="special">,</span> 
         <span class="keyword">typename</span> Allocator <span class="special">=</span> <span class="identifier">new_allocator</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">,</span> 
         <span class="keyword">typename</span> Options <span class="special">=</span> <span class="identifier">tree_assoc_defaults</span><span class="special">&gt;</span> 
<span class="keyword">class</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="comment">// types</span>
  <span class="keyword">typedef</span> <span class="identifier">Key</span>                                                                   <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a4cbd8bf06b740035e1e1cd8ed9e106e5"></a><span class="identifier">key_type</span><span class="special">;</span>              
  <span class="keyword">typedef</span> <span class="identifier">T</span>                                                                     <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a523f4830e3b2a7071e950bb4c3b1a054"></a><span class="identifier">mapped_type</span><span class="special">;</span>           
  <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">allocator_type</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad889fc8eda0237dde93a54b7aa4ff5a9"></a><span class="identifier">allocator_type</span><span class="special">;</span>        
  <span class="keyword">typedef</span> ::boost::container::allocator_traits<span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span>                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a1bda65858911901cba9dc8cbbcc50e77"></a><span class="identifier">allocator_traits_type</span><span class="special">;</span> 
  <span class="keyword">typedef</span> <a class="link" href="structboost_1_1container_1_1allocator__traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span>      <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a1ac6551a31ad643ec999055721e01144"></a><span class="identifier">value_type</span><span class="special">;</span>            
  <span class="keyword">typedef</span> <a class="link" href="structboost_1_1container_1_1allocator__traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">pointer</span>         <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a7a084898597dc4bd494c40a04aef8fba"></a><span class="identifier">pointer</span><span class="special">;</span>               
  <span class="keyword">typedef</span> <a class="link" href="structboost_1_1container_1_1allocator__traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">const_pointer</span>   <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1abb9d5cc153aaec311ff34dd1ffefbb6d"></a><span class="identifier">const_pointer</span><span class="special">;</span>         
  <span class="keyword">typedef</span> <a class="link" href="structboost_1_1container_1_1allocator__traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">reference</span>       <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa6c4fa10e92d6e3d574bb9f5a71b41e7"></a><span class="identifier">reference</span><span class="special">;</span>             
  <span class="keyword">typedef</span> <a class="link" href="structboost_1_1container_1_1allocator__traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">const_reference</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1acc2c0130ef3cb191213330bf1cabd55e"></a><span class="identifier">const_reference</span><span class="special">;</span>       
  <span class="keyword">typedef</span> <a class="link" href="structboost_1_1container_1_1allocator__traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">size_type</span>       <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a1b165a1eb9448fda2d53990fbd14e5de"></a><span class="identifier">size_type</span><span class="special">;</span>             
  <span class="keyword">typedef</span> <a class="link" href="structboost_1_1container_1_1allocator__traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">difference_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa3a4706be9e1dfa08968c985142e7a36"></a><span class="identifier">difference_type</span><span class="special">;</span>       
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aaee193348ff3e860eb07ffc30a8dfaa5"></a><span class="identifier">stored_allocator_type</span><span class="special">;</span> 
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a779030740118f46273e7b906489577cb"></a><span class="identifier">value_compare</span><span class="special">;</span>         
  <span class="keyword">typedef</span> <span class="identifier">Compare</span>                                                               <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa1b0bfdfcc2418db47f207fa0cb3d3d2"></a><span class="identifier">key_compare</span><span class="special">;</span>           
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ac9d4097211dfc851dc3df78f574a6c57"></a><span class="identifier">iterator</span><span class="special">;</span>              
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a390b3d376695da985c425afa1e955658"></a><span class="identifier">const_iterator</span><span class="special">;</span>        
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6ab5efe6e4f6523ecd9a6fb658075a62"></a><span class="identifier">reverse_iterator</span><span class="special">;</span>      
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad091aa93efe06f0c52bc7e04315b6d46"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span>
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a401dbb2638f1adbc8bf6b940b22c1028"></a><span class="identifier">movable_value_type</span><span class="special">;</span>    
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6024233456311161b00a2953a3904526"></a><span class="identifier">node_type</span><span class="special">;</span>             

  <span class="comment">// <a class="link" href="classboost_1_1container_1_1multimap.html#id56-bb">public member functions</a></span>
   <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a1736092f3ce021ddfa053ead39c020b3"><span class="identifier">BOOST_CONTAINER_STATIC_ASSERT</span></a><span class="special">(</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">allocator_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1affda2f6cf4cdfffad9b822f4406c6c43"><span class="identifier">multimap</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">explicit</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a2d4a966c1df5ce69db7ae574f2d209be"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">explicit</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6472c40196811ad6c54456fb34f64e3f"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab957c7dfc7bfec1b9ab492d7d9e65e71"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9f8e3f0a93b639259e19fdcccf893cba"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a936d14e4c2e981babb163197a873f737"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af846f05848d7c967f4c266bc7a1bcf14"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a5efe99d0c04e3e50ccb63d3f80fbfbb5"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> 
             <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1acb49d21e8a81380bb8be6324538a0743"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a5e2b3ca5c4fb0d245cdc727f82076c46"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ace405fc2906103292ad3abc722233e8b"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> 
             <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a364424065f3c264efffb5ed4c2539537"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> 
             <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a403ee21718644f23706dee62257ff02e"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a7c1750d7492c3998b41c6daca13de59e"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a3a57c6a379f3d1874ec919097581e7d5"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1afe9da377be2d20dff8478906fad39f23"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> 
           <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a75a4062735499e05054f556d0952b86e"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad74bb1f0ccf8174e58a34ed1f9222259"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> 
           <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a2383e848e8968032a143352b7ab10795"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> 
           <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1afd9dbf297cb8236b1f97832e840889cf"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a10f84f91dfb1bbd5c4e5067cd8757040"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a3c81ef395f2bcd61468f056f6a2d8c43"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a39c27d63d219a41a89333ee8e5da905d"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a255951d0b4e794992144dcb770f9dd31"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aead665d084abb3debcdc77a916714d01"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a756793b8926020922df08a7d47919875"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">allocator_type</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a939705b32a362e29776db1fb04da3dd7"><span class="identifier">get_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0f2c7eed18cff9651fd83ec9a10eb601"><span class="identifier">get_stored_allocator</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a1c09232a4f67b3b6300214639ec3d847"><span class="identifier">get_stored_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1abde50ea26b4d4afef36a03dacb34be75"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a736858799e7fbf65c80cd993fad71b47"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aef92dce3401c9403ed2c62ccf914a5b1"><span class="identifier">cbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6934b05159d13f33686e9f90cdbbf608"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6d615b3e821c5780ed4533e8f96bc9b9"><span class="identifier">cend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a368db23cca6402d18a7dc0a814a781ab"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af89b75d361df28498202d769b692e0c1"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa69904018e9e54d88988ed64031abb00"><span class="identifier">crbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ac04e8864cbb4f3ea3eacc5bcc5ccf164"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9ca39125438bb91711444c499e5d0289"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a5ee42a4197801bb961fb0b8eb1a11e84"><span class="identifier">crend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ae3ab9fa56fa1dd4d86e1af660630e61b"><span class="identifier">empty</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47"><span class="identifier">size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a07a41e61fc217ccd5b9c3687471f7794"><span class="identifier">max_size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a11c5d9729ad90584e5f5ead3392234b7"><span class="identifier">emplace</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aea741390c8b22962ad4a21a0b2d9801c"><span class="identifier">emplace_hint</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a91206f7171b1349ad2bbf3f2225131b4"><span class="identifier">insert</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a79d0c9ca70bb7e1a9f9409080c8c19be"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Pair<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a78505a5bd9d4f71841e0674e0793f8f7"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">Pair</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad2ec07c3c0e40716d68af16fd241b975"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a335b2fd94894a712bdc65a2907717bd3"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">movable_value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Pair<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a81fcad88651fb19f05ba4aec86358c6a"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Pair</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a587f39e4b48b472a05260a3dd49e5ea6"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a69bacd71fa3e9e0128c35bdc4b5db1dc"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aca3f2b046c68d35754b2b91c5d7a3e77"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">node_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a601f38de23b29acbf0a89dd33982ef73"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">node_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af72153af063cbc42df1d1e32aacf0630"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a41ecc2694cf3aa973187c8f395d982eb"><span class="identifier">erase</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0459171f2886d031941d40565d5489ec"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">node_type</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a52f04cacbd1a199d7dca79bc3d1f4075"><span class="identifier">extract</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">node_type</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a37d9fc84f409bd5d6ba83abea4914e78"><span class="identifier">extract</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad2116b7cf0e699fdfa7f0fdca343dc3e"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a3cd420edb40259b12ee4cc5216fc66fc"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a23d2393523c0c8290d4046409af2506e"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1map.html" title="Class template map">map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a34396949bae6d18c55ac2ffd6a1468e8"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1map.html" title="Class template map">map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0247469156c469afa34465d0388d5ec2"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multiset.html" title="Class template multiset">multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a688ed0322e645706ce98d465d3172cc7"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">key_compare</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a5774916f1eda7f0167935b4b66d0e49f"><span class="identifier">key_comp</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">value_compare</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a66cb46101a72a26c8dc69a87f9b010b8"><span class="identifier">value_comp</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ae7b071239a6f7d5f0ccfc3e758d45330"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a552acf41ee49e35a5b112937a7771133"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ac81150a15486b0b4151f930004d4418e"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6d7b5d60e90561f70fdbe02ac8ce7fe5"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6b93879cd31816816c63205e042d2282"><span class="identifier">count</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a24176ccf55c6d9f4e581e43c5f39a8dd"><span class="identifier">count</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a49a277661e7f942875153e2e7e1ce2c4"><span class="identifier">contains</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af3a285182795167062c8d53daa6bc927"><span class="identifier">contains</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a925b96ff38280ca5e060515654131102"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a148c12c554159377e5ecb051fcc7a564"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af3c08b94f120a8a91be493140054bb3b"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a8260ba992883669495ee432a245f02b5"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a3cfec883a72b21762d14f3c47d28aa69"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a91c94935b316fe5aeda43439d63032fc"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0c1c5a190a8b431018535b2ff4fd3035"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9f4150af3aaca5a67e3521994d9dab9b"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a849bffaa3ea4ed0a4793fa1f5ee2719d"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> 
  <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9f7bb470457159fe41368d05cdfbc64e"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a97f3eb9dffe225c608a7ee58957cd539"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> 
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a54f82ed6d139acd41cb925bf3fd5175c"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0563030ea5689d6b9a16578406f49729"><span class="identifier">rebalance</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>

  <span class="comment">// <a class="link" href="classboost_1_1container_1_1multimap.html#id57-bb">friend functions</a></span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a07f256348fcced36ba47ffab68d879e3"><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ac24c685d18fc157aa57fa0e475b0e1b0"><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a93da3bfadddebc2281c5c0498a11e06a"><span class="keyword">operator</span><span class="special">&lt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a4210b0c35a1039e3a9fdda5e4377f16c"><span class="keyword">operator</span><span class="special">&gt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad7f037094961a946da46f1415644a912"><span class="keyword">operator</span><span class="special">&lt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9e2e46a554be94875038236eaecf7703"><span class="keyword">operator</span><span class="special">&gt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a8489168d10935f9c35a0e4581c85e729"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span><span class="special">;</span></pre></div>
<div class="refsect1">
<a name="id-1.3.8.14.16.4.4"></a><h2>Description</h2>
<p>A multimap is a kind of associative container that supports equivalent keys (possibly containing multiple copies of the same key value) and provides for fast retrieval of values of another type T based on the keys. The multimap class supports bidirectional iterators.</p>
<p>A multimap satisfies all of the requirements of a container and of a reversible container and of an associative container. The <code class="computeroutput">value_type</code> stored by this container is the value_type is std::pair&lt;const Key, T&gt;.</p>
<p>
</p>
<div class="refsect2">
<a name="id-1.3.8.14.16.4.4.5"></a><h3>Template Parameters</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
<pre class="literallayout"><span class="keyword">typename</span> Key</pre>
<p>is the key_type of the map </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="keyword">typename</span> T</pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">typename</span> Compare <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span></pre>
<p>is the ordering function for Keys (e.g. <span class="emphasis"><em>std::less&lt;Key&gt;</em></span>). </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">typename</span> Allocator <span class="special">=</span> <span class="identifier">new_allocator</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span></pre>
<p>is the allocator to allocate the <code class="computeroutput">value_type</code>s (e.g. <span class="emphasis"><em>allocator&lt; std::pair&lt;const Key, T&gt; &gt; </em></span>). </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">typename</span> Options <span class="special">=</span> <span class="identifier">tree_assoc_defaults</span></pre>
<p>is an packed option type generated using using <a class="link" href="structboost_1_1container_1_1tree__assoc__options.html" title="Struct template tree_assoc_options">boost::container::tree_assoc_options</a>. </p>
</li>
</ol></div>
</div>
<div class="refsect2">
<a name="id-1.3.8.14.16.4.4.6"></a><h3>
<a name="id56-bb"></a><code class="computeroutput">multimap</code> public member functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem"><pre class="literallayout"> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a1736092f3ce021ddfa053ead39c020b3"></a><span class="identifier">BOOST_CONTAINER_STATIC_ASSERT</span><span class="special">(</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">allocator_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1affda2f6cf4cdfffad9b822f4406c6c43"></a><span class="identifier">multimap</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Default constructs an empty multimap.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">explicit</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a2d4a966c1df5ce69db7ae574f2d209be"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified allocator object and allocator.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">explicit</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6472c40196811ad6c54456fb34f64e3f"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab957c7dfc7bfec1b9ab492d7d9e65e71"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison and allocator.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9f8e3f0a93b639259e19fdcccf893cba"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap and inserts elements from the range [first ,last ).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a936d14e4c2e981babb163197a873f737"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified allocator, and inserts elements from the range [first ,last ).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af846f05848d7c967f4c266bc7a1bcf14"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and inserts elements from the range [first ,last ).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a5efe99d0c04e3e50ccb63d3f80fbfbb5"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> 
           <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and allocator, and inserts elements from the range [first ,last ).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1acb49d21e8a81380bb8be6324538a0743"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a5e2b3ca5c4fb0d245cdc727f82076c46"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> 
           <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ace405fc2906103292ad3abc722233e8b"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> 
           <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and allocator, and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a364424065f3c264efffb5ed4c2539537"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> 
           <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified allocator and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a403ee21718644f23706dee62257ff02e"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap and and inserts elements from the range [il.begin(), il.end()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is il.first() - il.end(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a7c1750d7492c3998b41c6daca13de59e"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified allocator, and inserts elements from the range [il.begin(), il.end()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is il.first() - il.end(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a3a57c6a379f3d1874ec919097581e7d5"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and inserts elements from the range [il.begin(), il.end()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is il.first() - il.end(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1afe9da377be2d20dff8478906fad39f23"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> 
         <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and allocator, and inserts elements from the range [il.begin(), il.end()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is il.first() - il.end(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a75a4062735499e05054f556d0952b86e"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty map and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad74bb1f0ccf8174e58a34ed1f9222259"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> 
         <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty map using the specified comparison object and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a2383e848e8968032a143352b7ab10795"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> 
         <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty map and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1afd9dbf297cb8236b1f97832e840889cf"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Copy constructs a multimap.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a10f84f91dfb1bbd5c4e5067cd8757040"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Move constructs a multimap. Constructs *this using x's resources.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Postcondition</strong></span>: x is emptied. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a3c81ef395f2bcd61468f056f6a2d8c43"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Copy constructs a multimap.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a39c27d63d219a41a89333ee8e5da905d"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Move constructs a multimap using the specified allocator. Constructs *this using x's resources. <span class="bold"><strong>Complexity</strong></span>: Constant if a == x.get_allocator(), linear otherwise.</p>
<p><span class="bold"><strong>Postcondition</strong></span>: x is emptied. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a255951d0b4e794992144dcb770f9dd31"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Makes *this a copy of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aead665d084abb3debcdc77a916714d01"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: this-&gt;swap(x.get()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a756793b8926020922df08a7d47919875"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Assign content of il to *this. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">allocator_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a939705b32a362e29776db1fb04da3dd7"></a><span class="identifier">get_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a copy of the allocator that was passed to the object's constructor.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0f2c7eed18cff9651fd83ec9a10eb601"></a><span class="identifier">get_stored_allocator</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a1c09232a4f67b3b6300214639ec3d847"></a><span class="identifier">get_stored_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1abde50ea26b4d4afef36a03dacb34be75"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the first element contained in the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a736858799e7fbf65c80cd993fad71b47"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aef92dce3401c9403ed2c62ccf914a5b1"></a><span class="identifier">cbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the end of the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6934b05159d13f33686e9f90cdbbf608"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6d615b3e821c5780ed4533e8f96bc9b9"></a><span class="identifier">cend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a368db23cca6402d18a7dc0a814a781ab"></a><span class="identifier">rbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a reverse_iterator pointing to the beginning of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af89b75d361df28498202d769b692e0c1"></a><span class="identifier">rbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the beginning of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa69904018e9e54d88988ed64031abb00"></a><span class="identifier">crbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the beginning of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ac04e8864cbb4f3ea3eacc5bcc5ccf164"></a><span class="identifier">rend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a reverse_iterator pointing to the end of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9ca39125438bb91711444c499e5d0289"></a><span class="identifier">rend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the end of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a5ee42a4197801bb961fb0b8eb1a11e84"></a><span class="identifier">crend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the end of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ae3ab9fa56fa1dd4d86e1af660630e61b"></a><span class="identifier">empty</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if the container contains no elements.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47"></a><span class="identifier">size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the number of the elements contained in the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a07a41e61fc217ccd5b9c3687471f7794"></a><span class="identifier">max_size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the largest possible size of the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a11c5d9729ad90584e5f5ead3392234b7"></a><span class="identifier">emplace</span><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span> args<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type T constructed with std::forward&lt;Args&gt;(args)... in the container. p is a hint pointing to where the insert should start to search.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> 
  <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aea741390c8b22962ad4a21a0b2d9801c"></a><span class="identifier">emplace_hint</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span> args<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type T constructed with std::forward&lt;Args&gt;(args)... in the container. p is a hint pointing to where the insert should start to search.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a91206f7171b1349ad2bbf3f2225131b4"></a><span class="identifier">insert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts x and returns the iterator pointing to the newly inserted element.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a79d0c9ca70bb7e1a9f9409080c8c19be"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Pair<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a78505a5bd9d4f71841e0674e0793f8f7"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">Pair</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value constructed from x and returns the iterator pointing to the newly inserted element.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad2ec07c3c0e40716d68af16fd241b975"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts a copy of x in the container. p is a hint pointing to where the insert should start to search.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a335b2fd94894a712bdc65a2907717bd3"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="identifier">movable_value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value move constructed from x in the container. p is a hint pointing to where the insert should start to search.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Pair<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a81fcad88651fb19f05ba4aec86358c6a"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="identifier">Pair</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value constructed from x in the container. p is a hint pointing to where the insert should start to search.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a587f39e4b48b472a05260a3dd49e5ea6"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: first, last are not iterators into *this.</p>
<p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [first,last) .</p>
<p><span class="bold"><strong>Complexity</strong></span>: At most N log(<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47">size()</a>+N) (N is the distance from first to last) </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a69bacd71fa3e9e0128c35bdc4b5db1dc"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [il.begin(), il.end().</p>
<p><span class="bold"><strong>Complexity</strong></span>: At most N log(<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47">size()</a>+N) (N is the distance from il.begin() to il.end()) </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aca3f2b046c68d35754b2b91c5d7a3e77"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">node_type</span> <span class="special">&amp;&amp;</span> nh<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: nh is empty or this-&gt;<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a939705b32a362e29776db1fb04da3dd7">get_allocator()</a> == nh.get_allocator().</p>
<p><span class="bold"><strong>Effects/Returns</strong></span>: If nh is empty, has no effect and returns <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a>. Otherwise, inserts the element owned by nh and returns an iterator pointing to the newly inserted element. If a range containing elements with keys equivalent to nh.key() exists, the element is inserted at the end of that range. nh is always emptied.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a601f38de23b29acbf0a89dd33982ef73"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> hint<span class="special">,</span> <span class="identifier">node_type</span> <span class="special">&amp;&amp;</span> nh<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Same as <code class="computeroutput">insert(node_type &amp;&amp; nh)</code> but the element is inserted as close as possible to the position just prior to "hint".</p>
<p><span class="bold"><strong>Complexity</strong></span>: logarithmic in general, but amortized constant if the element is inserted right before "hint". </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af72153af063cbc42df1d1e32aacf0630"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Erases the element pointed to by p.</p>
<p><span class="bold"><strong>Returns</strong></span>: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Amortized constant time    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a41ecc2694cf3aa973187c8f395d982eb"></a><span class="identifier">erase</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: If present, erases the element in the container with key equivalent to x.</p>
<p><span class="bold"><strong>Returns</strong></span>: Returns the number of erased elements (0/1).</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size()) + count(k)    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0459171f2886d031941d40565d5489ec"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> first<span class="special">,</span> <span class="identifier">const_iterator</span> last<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Erases all the elements in the range [first, last).</p>
<p><span class="bold"><strong>Returns</strong></span>: Returns last.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size())+N where N is the distance from first to last.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">node_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a52f04cacbd1a199d7dca79bc3d1f4075"></a><span class="identifier">extract</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> k<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Removes the first element in the container with key equivalent to k.</p>
<p><span class="bold"><strong>Returns</strong></span>: A node_type owning the element if found, otherwise an empty node_type.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size()).    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">node_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a37d9fc84f409bd5d6ba83abea4914e78"></a><span class="identifier">extract</span><span class="special">(</span><span class="identifier">const_iterator</span> position<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Removes the element pointed to by "position".</p>
<p><span class="bold"><strong>Returns</strong></span>: A node_type owning the element, otherwise an empty node_type.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Amortized constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad2116b7cf0e699fdfa7f0fdca343dc3e"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: this-&gt;<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a939705b32a362e29776db1fb04da3dd7">get_allocator()</a> == source.get_allocator().</p>
<p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
<p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
<p><span class="bold"><strong>Complexity</strong></span>: N log(<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47">size()</a> + N) (N has the value source.size()) </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a3cd420edb40259b12ee4cc5216fc66fc"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: this-&gt;<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a939705b32a362e29776db1fb04da3dd7">get_allocator()</a> == source.get_allocator().</p>
<p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
<p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
<p><span class="bold"><strong>Complexity</strong></span>: N log(<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47">size()</a> + N) (N has the value source.size())    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a23d2393523c0c8290d4046409af2506e"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1map.html" title="Class template map">map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: this-&gt;<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a939705b32a362e29776db1fb04da3dd7">get_allocator()</a> == source.get_allocator().</p>
<p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
<p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
<p><span class="bold"><strong>Complexity</strong></span>: N log(<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47">size()</a> + N) (N has the value source.size())    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a34396949bae6d18c55ac2ffd6a1468e8"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1map.html" title="Class template map">map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: this-&gt;<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a939705b32a362e29776db1fb04da3dd7">get_allocator()</a> == source.get_allocator().</p>
<p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
<p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
<p><span class="bold"><strong>Complexity</strong></span>: N log(<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47">size()</a> + N) (N has the value source.size())    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0247469156c469afa34465d0388d5ec2"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multiset.html" title="Class template multiset">multiset</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Swaps the contents of *this and x.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a688ed0322e645706ce98d465d3172cc7"></a><span class="identifier">clear</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: erase(<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1abde50ea26b4d4afef36a03dacb34be75">begin()</a>,<a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a>).</p>
<p><span class="bold"><strong>Postcondition</strong></span>: <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47">size()</a> == 0.</p>
<p><span class="bold"><strong>Complexity</strong></span>: linear in <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1aa64883f68653b0b2e56fc1101606ac47">size()</a>.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">key_compare</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a5774916f1eda7f0167935b4b66d0e49f"></a><span class="identifier">key_comp</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the comparison object out of which a was constructed.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">value_compare</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a66cb46101a72a26c8dc69a87f9b010b8"></a><span class="identifier">value_comp</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns an object of value_compare constructed out of the comparison object.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ae7b071239a6f7d5f0ccfc3e758d45330"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to an element with the key equivalent to x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a552acf41ee49e35a5b112937a7771133"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to an element with the key equivalent to x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ac81150a15486b0b4151f930004d4418e"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to an element with the key equivalent to x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6d7b5d60e90561f70fdbe02ac8ce7fe5"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: A const_iterator pointing to an element with the key equivalent to x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a6b93879cd31816816c63205e042d2282"></a><span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: The number of elements with key equivalent to x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size())+count(k) </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a24176ccf55c6d9f4e581e43c5f39a8dd"></a><span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: The number of elements with key equivalent to x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size())+count(k) </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a49a277661e7f942875153e2e7e1ce2c4"></a><span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: Returns true if there is an element with key equivalent to key in the container, otherwise false.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af3a285182795167062c8d53daa6bc927"></a><span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: Returns true if there is an element with key equivalent to key in the container, otherwise false.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a925b96ff38280ca5e060515654131102"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key not less than x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a148c12c554159377e5ecb051fcc7a564"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key not less than x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1af3c08b94f120a8a91be493140054bb3b"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key not less than x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a8260ba992883669495ee432a245f02b5"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key not less than x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a3cfec883a72b21762d14f3c47d28aa69"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key greater than x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a91c94935b316fe5aeda43439d63032fc"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key greater than x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0c1c5a190a8b431018535b2ff4fd3035"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key greater than x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9f4150af3aaca5a67e3521994d9dab9b"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key greater than x, or <a class="link" href="classboost_1_1container_1_1multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ab2e90b8278dfe485a74d91516733127c">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a849bffaa3ea4ed0a4793fa1f5ee2719d"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> 
<a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9f7bb470457159fe41368d05cdfbc64e"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a97f3eb9dffe225c608a7ee58957cd539"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> 
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a54f82ed6d139acd41cb925bf3fd5175c"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a0563030ea5689d6b9a16578406f49729"></a><span class="identifier">rebalance</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Rebalances the tree. It's a no-op for Red-Black and AVL trees.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear </p>
</li>
</ol></div>
</div>
<div class="refsect2">
<a name="id-1.3.8.14.16.4.4.7"></a><h3>
<a name="id57-bb"></a><code class="computeroutput">multimap</code> friend functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a07f256348fcced36ba47ffab68d879e3"></a><span class="keyword">operator</span><span class="special">==</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are equal</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ac24c685d18fc157aa57fa0e475b0e1b0"></a><span class="keyword">operator</span><span class="special">!=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are unequal</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a93da3bfadddebc2281c5c0498a11e06a"></a><span class="keyword">operator</span><span class="special">&lt;</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is less than y</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a4210b0c35a1039e3a9fdda5e4377f16c"></a><span class="keyword">operator</span><span class="special">&gt;</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is greater than y</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1ad7f037094961a946da46f1415644a912"></a><span class="keyword">operator</span><span class="special">&lt;=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or less than y</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a9e2e46a554be94875038236eaecf7703"></a><span class="keyword">operator</span><span class="special">&gt;=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or greater than y</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1multimap_1a8489168d10935f9c35a0e4581c85e729"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <a class="link" href="classboost_1_1container_1_1multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: x.swap(y)</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
</ol></div>
</div>
</div>
</div>
<div class="copyright-footer">Copyright © 2009-2018 Ion Gaztanaga<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="classboost_1_1container_1_1map.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#doxygen.boost_container_header_reference.map_8hpp"><img src="../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="structboost_1_1container_1_1pmr_1_1map__of.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
